﻿//#include<iostream>
//using namespace std;
//#include <string>

////贪心算法 1题
//class Solution {
//public:
//    bool lemonadeChange(vector<int>& bills) {
//
//        int five = 0, ten = 0;
//        for (auto x : bills)
//        {
//            if (x == 5)five++;
//            else if (x == 10)
//            {
//                if (five == 0)return false;
//                five--; ten++;
//            }
//            else
//            {
//                if (five && ten)
//                {
//                    five--; ten--;
//                }
//                else if (five >= 3)
//                    five -= 3;
//                else return false;
//            }
//        }
//        return true;
//    }
//};
//
//
//
////贪心算法第2题
//class Solution {
//public:
//    int halveArray(vector<int>& nums) {
//        priority_queue<double> heap;
//
//        double sum = 0.0;
//        for (int x : nums)
//        {
//            heap.push(x);
//            sum += x;
//        }
//        sum /= 2.0;
//
//        int count = 0;
//        while (sum > 0)
//        {
//            double t = heap.top() / 2.0;
//            heap.pop();
//            sum -= t;
//            count++;
//            heap.push(t);
//        }
//        return count;
//    }
//};



/////////////////////////////////////////////////////
//蓝桥杯
/*题目描述
给定 L, R，问 L ≤ x ≤ R 中有多少个数 x 满足存在整数 y,z 使得 x = y2 − z2。
输入格式
输入一行包含两个整数 L, R，用一个空格分隔。
输出格式
输出一行包含一个整数满足题目给定条件的 x 的数量。
样例输入
1 5
样例输出
4
提示
1 = 12 − 02 ；
3 = 22 − 12 ；
4 = 22 − 02 ；
5 = 32 − 22 。


对于 40% 的评测用例，LR ≤ 5000 ；
对于所有评测用例，1 ≤ L ≤ R ≤ 109 。
*/
/*
 规律：只有当x为奇数或4的倍数时才能拆分为两个数的平方差。
	x=(y-z)(y+z)
	1,3,4,5
	y 1 2 2 3 3 3 4  4  4  4 5  5  5  5  5 ……
	z 0 0 1 0 1 2 0  1  2  3 0  1  2  3  4 ……
	x 1 4 3 9 8 5 16 15 12 7 25 24 21 16 9 ……

	z == 0     =>  y^2    1，4，9，16，25  其中的偶数都是4的倍数，其余全是奇数，可以分到下面两类
	y-z=1,3奇  =>  1,3,5,7,9,11……奇数
	y-z=2,4偶  =>  4的倍数
	 
 */
//int F(int x)
//{
//	//这里的 x/4 能计算出 1到 x 中有几个4的倍数
//	// (x+1)/2 能计算出 1到 x 中有几个奇数
//	return x / 4 + (x + 1) / 2;
//}
//int main()
//{
//	int l = 0, r = 0;
//	cin >> l >> r;
//	//因为减号(被减数)是开区间，但是题目中要求的是闭区间，所以[l,r] <=> (l-1,r]
//	cout << F(r) - F(l-1);
//	return 0;
//}


/*
题目 3143: 蓝桥杯2023年第十四届省赛真题-更小的数
蓝桥杯2023年第十四届省赛真题-更小的数

小蓝有一个长度均为 n 且仅由数字字符 0 ∼ 9 组成的字符串，下标从 0 到 n − 1，你可以将其视作是一个具有 n 位的十进制数字 num，小蓝可以从 num 中选出一段连续的子串并将子串进行反转，最多反转一次。小蓝想要将选出的子串进行反转后再放入原位置处得到的新的数字 numnew 满足条件 numnew < num，请你帮他计算下一共有多少种不同的子串选择方案，只要两个子串在 num 中的位置不完全相同我们就视作是不同的方案。
注意，我们允许前导零的存在，即数字的最高位可以是 0 ，这是合法的。

输入格式
输入一行包含一个长度为 n 的字符串表示 num（仅包含数字字符 0 ∼ 9），
从左至右下标依次为 0 ∼ n − 1。
输出格式
输出一行包含一个整数表示答案。
样例输入
210102
样例输出
8
提示
一共有 8 种不同的方案：
1）所选择的子串下标为 0 ∼ 1 ，反转后的 numnew = 120102 < 210102 ；
2）所选择的子串下标为 0 ∼ 2 ，反转后的 numnew = 012102 < 210102 ；
3）所选择的子串下标为 0 ∼ 3 ，反转后的 numnew = 101202 < 210102 ；
4）所选择的子串下标为 0 ∼ 4 ，反转后的 numnew = 010122 < 210102 ；
5）所选择的子串下标为 0 ∼ 5 ，反转后的 numnew = 201012 < 210102 ；
6）所选择的子串下标为 1 ∼ 2 ，反转后的 numnew = 201102 < 210102 ；
7）所选择的子串下标为 1 ∼ 4 ，反转后的 numnew = 201012 < 210102 ；
8）所选择的子串下标为 3 ∼ 4 ，反转后的 numnew = 210012 < 210102 ；

对于 20% 的评测用例，1 ≤ n ≤ 100 ；
对于 40% 的评测用例，1 ≤ n ≤ 1000 ；
对于所有评测用例，1 ≤ n ≤ 5000 。
*/
//#include<iostream>
//#include <string>
//using namespace std;
//
//string reverseString1(string s, int left, int right)
//{
//	while(left<right)
//	{
//		swap(s[left], s[right]);
//		left++; 
//		right--;
//	}
//	return s;
//}
//int reverseString2(string s, int l, int r)
//{
//	while (l < r)
//	{
//		if (s[l] > s[r]) 
//			return 1;
//		else if (s[l] == s[r]) 
//		{ 
//			l++; 
//			r--; 
//		}
//		else 
//			return 0;
//	}
//}
//
//int main()
//{
//	string num;
//	cin >> num;
//	int n = num.size();
//	int count1 = 0;
//	int count2 = 0;
//	int left = 0;
//	int right = 1;
//	while (left < n-1)
//	{
//		while (right < n)
//		{
//			string newnum = reverseString1(num, left, right);
//			if (newnum < num)
//				count1++;
//
//			if(reverseString2(num, left, right))
//				count2++;	
//
//			right++;
//		}
//		left++;
//		right = left + 1;
//	}
//	cout << "count1=" << count1 << endl;
//	cout << "count2=" << count2 << endl;
//
//	return 0;
//}


//#include<iostream>
//#include <string>
//using namespace std;
//string s;
//int reverseString(int l, int r)
//{
//	while (l < r)
//	{
//		if (s[l] > s[r]) return 1;
//		else if (s[l] == s[r]) { l++; r--; }
//		else break;
//	}
//	return 0;
//}
//
//int main()
//{
//	cin >> s;
//	int n = s.size();
//	int count = 0;
//	int left = 0;
//	int right = 1;
//	while (left < n - 1)
//	{
//		while (right < n)
//		{
//			if (reverseString(left, right))
//				count++;
//			right++;
//		}
//		left++;
//		right = left + 1;
//	}
//	cout << count;
//	return 0;
//}

//int main() {
	//cin >> s;
	//int n = s.length();//n是字符串长度
	//int ans = 0;//记录答案
	//for (int l = 0; l <= n - 2; l++) {//l即left是子串的起始下标，从0开始到n-2（子串长度至少为2，最右侧的最小子串下标为[n-2,n-1],故l最多到n-2）
	//	for (int r = n - 1; r > l; r--) {//r即right是子串的末尾下标，从s的最末下标n-1到l+1。
	//		if (F(l, r))ans++;
	//	}
	//}
	//cout << ans;
//	return 0;
//}

/*
题目描述
小蓝正在一个瓜摊上买瓜。瓜摊上共有 n 个瓜，每个瓜的重量为 Ai 。
小蓝刀功了得，他可以把任何瓜劈成完全等重的两份，不过每个瓜只能劈一刀。
小蓝希望买到的瓜的重量的和恰好为 m 。
请问小蓝至少要劈多少个瓜才能买到重量恰好为 m 的瓜。如果无论怎样小蓝都无法得到总重恰好为 m 的瓜，请输出 −1 。
输入格式
输入的第一行包含两个整数 n, m，用一个空格分隔，分别表示瓜的个数和小蓝想买到的瓜的总重量。
第二行包含 n 个整数 Ai，相邻整数之间使用一个空格分隔，分别表示每个瓜的重量。
输出格式
输出一行包含一个整数表示答案。
样例输入
3 10
1 3 13
样例输出
2
*/
//#include<iostream>
//using namespace std;
//
//
//int main()
//{
//	int n = 0, m = 0;
//	cin >> n >> m;
//	int* a = (int*)malloc(sizeof(int) * n);
//	for (int i = 0; i < n; i++)
//	{
//		cin >> a[i];
//	}
//
//	double sum = 0.0;
//	int i = 0;
//	while (i<n && sum <= m)
//	{
//		sum += a[i++];
//	}
//	if (i == n)//瓜不够
//		cout << -1 << endl;
//	else if(sum-a[i-1]/2 != m)//劈出来不符合要求
//		cout << -1 << endl;
//	else
//		cout << i-1 << endl;
//
//	return 0;
//}


/*
题目描述
小蓝有一个神奇的炉子用于将普通金属 O 冶炼成为一种特殊金属 X。这个炉子有一个称作转换率的属性 V，V 是一个正整数，这意味着消耗 V 个普通金

属 O 恰好可以冶炼出一个特殊金属 X，当普通金属 O 的数目不足 V 时，无法继续冶炼。
现在给出了 N 条冶炼记录，每条记录中包含两个整数 A 和 B，这表示本次投入了 A 个普通金属 O，最终冶炼出了 B 个特殊金属 X。每条记录都是独立
的，这意味着上一次没消耗完的普通金属 O 不会累加到下一次的冶炼当中。

根据这 N 条冶炼记录，请你推测出转换率 V 的最小值和最大值分别可能是多少，题目保证评测数据不存在无解的情况。

输入格式
第一行一个整数 N，表示冶炼记录的数目。
接下来输入 N 行，每行两个整数 A、B，含义如题目所述。
输出格式
输出两个整数，分别表示 V 可能的最小值和最大值，中间用空格分开。
样例输入
3
75 3
53 2
59 2
样例输出
20 25
提示
当 V = 20 时，有：⌊75/20⌋ = 3，⌊ 53/20 ⌋ = 2，⌊ 59/20 ⌋ = 2，可以看到符合所有冶炼记录。
当 V = 25 时，有：⌊75/25⌋ = 3，⌊ 53/25 ⌋ = 2，⌊ 59/25 ⌋ = 2，可以看到符合所有冶炼记录。
且再也找不到比 20 更小或者比 25 更大的符合条件的 V 值了。
*/
//#include<iostream>
//using namespace std;
//int main()
//{
//	int n = 0;
//	cin >> n;
//	int a = 0, b = 0, max = 0, min = 0, flag = 0;
//
//	for (int i = 0; i < n; i++)
//	{
//		cin >> a >> b;
//		
//		if (flag == 0)
//		{//初始化max和min，用第一个输入数据来初始化
//			max = a / b;
//			min = a / (b + 1);
//			flag = 1;
//		}
//		if (a/b < max && flag == 1)//维护上限为最小上限
//		{
//			max = a / b;
//		}
//		if (a / (b + 1) > min && flag == 1)//维护下限为最大下限
//		{
//			min = a / (b + 1);
//		}
//	}
//
//	cout << max << " " << min + 1;
//
//	return 0;
//}

//#include <iostream> 
//using namespace std;
//int main()
//{
//    int n, a, b, Min = 0, Max = 0, flags = 0;//flags标记是否为第一次输入
//    cin >> n;
//    while (n--)//表示输入n组数据
//    {
//        cin >> a >> b;//输入普通金属、特殊金属数量
//        if (a / b < Max && flags == 1)//维护上限最小值
//        {
//            Max = a / b;
//        }
//        if (a / (b + 1) > Min && flags == 1)//维护下限最大值
//        {
//            Min = a / (b + 1);
//        }
//        if (flags == 0)//让第一次输入的数据作为大小判断的成员，这样就不用考虑Max、Min的初始值
//        {
//            Max = a / b;
//            Min = a / (b + 1);
//            flags = 1;//标记已经初始化
//        }
//    }
//    cout << Min + 1 << " " << Max;//因为下线不能触碰，得加1
//    return 0;
//}


/*I
【问题描述】小蓝现在有一个长度为100的数组，数组中的每个元素的值都在О到9的范围之内。数组中的元素从左至右如下所示:
568 69 1 6 12 4 9 198 236 477595038758158 618 30 379 270588 5 7 0 9 9 1 9 4 4 68 6 338 5 16 34 67078 2768 9 56 56 140 10 09 4 8 09 1 2850253 3

 现在他想要从这个数组中寻找一些满足以下条件的子序列:
1.子序列的长度为8;
2.这个子序列可以按照下标顺序组成一个yyyymmdd 格式的日期，并且要求这个日期是2023年中的某一天的日期，例如20230902，20231223。yyyy表示年份，mm表示月份，dd表示天数，当月份或者天数的长度只有一位时需要一个前导零补充。
请你帮小蓝计算下按上述条件一共能找到多少个不同的2023年的日期。对于相同的日期你只需要统计一次即可。
【答案提交】5 6 8 6 9 1 6 1 2 4 9 1 98 2 3647759 5 0 38 758 158 6 18 3 0 3 7 9 270 5885 709 9 1 9 4 4 6 86 3 38 5 16 3467078 2 76 8 9 5656 1 40 10 0 9 4 80 9 1 2850 253 3
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
*/
//#include<iostream>
//using namespace std;
//int main()
//{
//	int a[100] = { 5,6,8,6,9,1,6,1,2,4,9,1,9,8,2,3,6,4,7,7,5,9,5,0,3,8,7,5,8,1,5,8,6,1,8,3,
//		0,3,7,9,2,7,0,5,8,8,5,7, 0, 9, 9, 1, 9, 4, 4, 6,8, 6, 3,3,8,5, 1,6, 3,4, 6,7,0,7,
//		8, 2,7,6,8, 9, 5,6, 5,6, 1,4,0, 1,0, 0,9, 4, 8, 0,9, 1, 2,8,5,0,2,5,3, 3 };
//	int b[6] = { 66,35,97,95,94,93 };
//	long long ret = 1;
//	for (int i = 0; i < 6; i++)
//	{
//		ret *= b[i];
//		cout << ret << endl;
//	}
//	cout << ret << endl;
//	
//	return 0;
//}

/*
 题目描述
对于一个长度为 K 的整数数列：A1, A2, . . . , AK，我们称之为接龙数列当且仅当 Ai 的首位数字恰好等于 Ai−1 的末位数字 (2 ≤ i ≤ K)。
例如 12, 23, 35, 56, 61, 11 是接龙数列；12, 23, 34, 56 不是接龙数列，因为 56的首位数字不等于 34 的末位数字。所有长度为 1 的整数数列都是接龙数列。
现在给定一个长度为 N 的数列 A1, A2, . . . , AN，请你计算最少从中删除多少个数，可以使剩下的序列是接龙序列？
输入格式
第一行包含一个整数 N。
第二行包含 N 个整数 A1, A2, . . . , AN。
输出格式
一个整数代表答案。
样例输入
5
11 121 22 12 2023
样例输出
1
*/

//#include<iostream>
//using namespace std;
//int main()
//{
//	//int n = 0;
//	//int* a = new int(sizeof(int) * n);
//	//cin >> n;
//	//int k = n;
//	//for (int i = 0; i < n; i++)
//	//	cin >> a[i];
//
//	int a[] = { 389,789,443,933,345,765,467,443,933,345,765,467,933,345,765,567 };
//	int n = sizeof(a) / sizeof(a[0]);
//	int k = n;
//	for (int i = 1; i < n; i++)
//	{
//		int end = a[i - 1] % 10;
//		int begin = a[i];
//		while (begin > 10)
//			begin /= 10;
//		if (end != begin)
//		{
//			for (int j = i + 1; j < n; j++)
//			{
//				a[j - 1] = a[j];
//			}
//			n--;
//			i--;
//		}
//	}
//	cout << k << endl;
//	cout << n << endl;
//	cout << k - n << endl;
//	for (int i = 0; i < n; i++)
//		cout << a[i] << " ";
//	return 0;
//}

//#include<iostream>
//using namespace std;
//int main()
//{
//	int n = 0;
//	int* a = new string;
//	cin >> n;
//	int k = n;
//	for (int i = 0; i < n; i++)
//		cin >> a[i];
//
//	int a[] = { 389,789,443,933,345,765,467,443,933,345,765,467,933,345,765,567 };
//	int n = sizeof(a) / sizeof(a[0]);
//	int k = n;
//	for (int i = 1; i < n; i++)
//	{
//		int end = a[i - 1] % 10;
//		int begin = a[i];
//		while (begin > 10)
//			begin /= 10;
//		if (end != begin)
//		{
//			for (int j = i + 1; j < n; j++)
//			{
//				a[j - 1] = a[j];
//			}
//			n--;
//			i--;
//		}
//	}
//	cout << k << endl;
//	cout << n << endl;
//	cout << k - n << endl;
//	for (int i = 0; i < n; i++)
//		cout << a[i] << " ";
//	return 0;
//}



//#include<iostream>
//using namespace std;
//int dp[10]; //以数字i结尾的最长子串长度，i:0 ~ 9
//int main()
//{
//	int n, maxx = 0;
//	cin >> n;
//	for (int i = 0; i < n; i++)
//	{
//		string s;
//		cin >> s;
//		int a, b;
//		a = s[0] - '0', b = s.back() - '0';//当前Ai:a...b
//		//若前面有以a结尾的数，则以b结尾的连续子序列长度+1
//		//若前面没有以a结尾的数，则以b结尾的连续子序列与之前相等
//		dp[b] = max(dp[b], dp[a] + 1);
//		maxx = max(maxx, dp[b]);   //最长的连续子序列长度
//	}
//	cout << n - maxx << endl;
//	cout << "dp[i]  =>  ";
//	for (int i = 0; i < 10; i++)
//	{
//		cout << dp[i] << " ";
//	}
//	cout << endl;
//	return 0;
//}


//若前面有以a结尾的数，则以b结尾的连续子序列长度+1
//若前面没有以a结尾的数，则以b结尾的连续子序列与之前相等
// 14  422  22  258  327  712
//dp[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 //i = 0   a = 1  b = 4  dp[4] = (dp[1], dp[1] + 1) = (0,1) = 1  maxx = (0,1) = 1  dp[10] = { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 };
 //i = 1   a = 4  b = 2  dp[2] = (dp[2], dp[4] + 1) = (0, 1+1) = 2  maxx = (1, 2) = 2  dp[10] = { 0, 2, 0, 0, 1, 0, 0, 0, 0, 0 };
 //i = 2   a = 2  b = 2  dp[2] = (dp[2], dp[2] + 1) = (0, 2 + 1) = 3  maxx = (2, 3) = 3  dp[10] = { 0, 0, 3, 1, 0, 0, 0, 0, 0 };
 //i = 3   a = 2  b = 8  dp[8] = (dp[8], dp[2] + 1) = (0, 3 + 1) = 4  maxx = (3, 4) = 4  dp[10] = { 0, 0, 3, 0, 1, 0, 0, 0, 4, 0 };
 //i = 4   a = 3  b = 7  dp[7] = (dp[7], dp[3] + 1) = (0, 0 + 1) = 1  maxx = (4, 1) = 4  dp[10] = { 0, 0, 3, 0, 1, 0, 0, 1, 4, 0 };
 //i = 5   a = 7  b = 2  dp[2] = (dp[2], dp[7] + 1) = (3, 1 + 1) = 3  maxx = (4, 3) = 4  dp[10] = { 0, 0, 3, 0, 1, 0, 0, 1, 4, 0 };
//																						dp[i] = >   0, 0, 3, 0, 1, 0, 0, 1, 4, 0


		// 14  422  22  258  222  212
//dp[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 //i = 0   a = 1  b = 4  dp[4] = (dp[1], dp[1] + 1) = (0,1) = 1  maxx = (0,1) = 1  dp[10] = { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 };
 //i = 1   a = 4  b = 2  dp[2] = (dp[2], dp[4] + 1) = (0, 1+1) = 2  maxx = (1, 2) = 2  dp[10] = { 0, 0, 2, 0, 1, 0, 0, 0, 0, 0 };
 //i = 2   a = 2  b = 2  dp[2] = (dp[2], dp[2] + 1) = (0, 2 + 1) = 3  maxx = (2, 3) = 3  dp[10] = { 0, 0, 3, 0, 1, 0, 0, 0, 0, 0 };
 //i = 3   a = 2  b = 8  dp[8] = (dp[8], dp[2] + 1) = (0, 3 + 1) = 4  maxx = (3, 4) = 4  dp[10] = { 0, 0, 3, 0, 1, 0, 0, 0, 4, 0 };
 //i = 4   a = 2  b = 2  dp[2] = (dp[2], dp[2] + 1) = (3, 3 + 1) = 4  maxx = (4, 4) = 4  dp[10] = { 0, 0, 4, 0, 1, 0, 0, 0, 4, 0 };
 //i = 5   a = 2  b = 2  dp[2] = (dp[2], dp[2] + 1) = (4, 4 + 1) = 5  maxx = (4, 5) = 5  dp[10] = { 0, 0, 5, 0, 1, 0, 0, 0, 4, 0 };
//																									0 0 5 0 1 0 0 0 4 0



/*
题目 3158: 蓝桥杯2023年第十四届省赛真题-三国游戏
时间限制: 3s 内存限制: 320MB 提交: 5605 解决: 1298
题目描述
小蓝正在玩一款游戏。游戏中魏蜀吴三个国家各自拥有一定数量的士兵X, Y, Z (一开始可以认为都为 0 )。游戏有 n 个可能会发生的事件，
每个事件之间相互独立且最多只会发生一次，当第 i 个事件发生时会分别让 X, Y, Z 增加Ai , Bi ,Ci 。
当游戏结束时 (所有事件的发生与否已经确定)，如果 X, Y, Z 的其中一个大于另外两个之和，我们认为其获胜。
例如，当 X > Y + Z 时，我们认为魏国获胜。小蓝想知道游戏结束时如果有其中一个国家获胜，最多发生了多少个事件?
如果不存在任何能让某国获胜的情况，请输出 −1 。
输入格式
输入的第一行包含一个整数 n 。
第二行包含 n 个整数表示 Ai，相邻整数之间使用一个空格分隔。
第三行包含 n 个整数表示 Bi，相邻整数之间使用一个空格分隔。
第四行包含 n 个整数表示 Ci，相邻整数之间使用一个空格分隔。
输出格式
输出一行包含一个整数表示答案。
样例输入
3
1 2 2
2 3 2
1 0 7
样例输出
2
提示
发生两个事件时，有两种不同的情况会出现获胜方。
发生 1, 2 事件时蜀国获胜。
发生 1, 3 事件时吴国获胜。

对于 40% 的评测用例，n ≤ 500 ；
对于 70% 的评测用例，n ≤ 5000 ；
对于所有评测用例，1 ≤ n ≤ 105，1 ≤ Ai , Bi ,Ci ≤ 109
*/

#include<iostream>
using namespace std;
int main()
{
	int n;
	cin >> n;
	//int a[3][n]; //vs不支持变长数组
	int* A = new int(n);
	int* B = new int(n);
	int* C = new int(n);
	for (int i = 0; i < n; ++i)
	{
		cin >> A[i];
	}
	for (int i = 0; i < n; ++i)
	{
		cin >> B[i];
	}

	int count = 0;
	for (int i = 0; i < n; i++)
	{
		
	}

	return 0;
}